import re


def 提取括号内容(s: str, start_idx: int):
    """
    提取字符串中从 start_idx 开始的最外层括号内的内容，支持嵌套括号。

    参数:
        s (str): 要解析的字符串。
        start_idx (int): 开始解析的索引。

    返回:
        tuple: 括号内的内容字符串和结束索引。
    """
    stack = []
    content = ''
    i = start_idx
    while i < len(s):
        char = s[i]
        if char in '([':
            stack.append(char)
            if len(stack) > 1:
                content += char
        elif char in ')]':
            stack.pop()
            if stack:
                content += char
            else:
                return content, i
        else:
            if stack:
                content += char
        i += 1
    raise ValueError("括号不匹配")


def 拆解赋值(target_str: str, annotation_str: str, value_str: str, indent: str) -> str:
    """
    将解包赋值拆解为单独的类型注解和赋值操作。

    参数:
        target_str (str): 赋值目标字符串。
        annotation_str (str): 类型注解字符串。
        value_str (str): 赋值值字符串。
        indent (str): 当前行的缩进字符串。

    返回:
        str: 拆解后的赋值代码。
    """
    拆解代码 = ""

    def 递归拆解(target, annotation, value, current_indent):
        target = target.strip()
        annotation = annotation.strip()
        value = value.strip()

        if (target.startswith('(') and target.endswith(')')) or (target.startswith('[') and target.endswith(']')):
            # 提取内部内容
            inner_target, _ = 提取括号内容(target, 0)
            inner_annotation, _ = 提取括号内容(annotation, 0)
            inner_value, _ = 提取括号内容(value, 0)

            # 使用逗号分隔
            targets = split_elements(inner_target)
            annotations = split_elements(inner_annotation)
            values = split_elements(inner_value)

            if not (len(targets) == len(annotations) == len(values)):
                raise ValueError("解包赋值的目标、类型注解和赋值的元素数量不一致。")

            for t, a, v in zip(targets, annotations, values):
                递归拆解(t, a, v, current_indent)
        else:
            # 创建类型注解行
            拆解代码_inner = f"{current_indent}{target}: {annotation}\n"
            # 创建赋值行
            拆解代码_inner += f"{current_indent}{target} = {value}\n"
            nonlocal 拆解代码
            拆解代码 += 拆解代码_inner

    递归拆解(target_str, annotation_str, value_str, indent)
    return 拆解代码


def split_elements(s: str) -> list:
    """
    根据逗号分隔字符串元素，支持嵌套结构。

    参数:
        s (str): 要分割的字符串。

    返回:
        list: 分割后的元素列表。
    """
    elements = []
    current = ''
    stack = []
    for char in s:
        if char in '([':
            stack.append(char)
            current += char
        elif char in ')]':
            stack.pop()
            current += char
        elif char == ',' and not stack:
            elements.append(current.strip())
            current = ''
        else:
            current += char
    if current:
        elements.append(current.strip())
    return elements


def 拆解源代码中的注解赋值(源代码: str) -> str:
    """
    解析源代码，将其中的 AnnAssign 节点拆解为类型注解和赋值操作。
    支持简单变量赋值、属性赋值、索引赋值、元组解包、列表解包及嵌套解包赋值。

    参数:
        源代码 (str): 需要拆解的 Python 源代码字符串。

    返回:
        str: 拆解后的合法 Python 源代码字符串。
    """
    拆解后的代码 = ""
    lines = 源代码.split('\n')
    for line in lines:
        stripped = line.strip()
        if not stripped:
            拆解后的代码 += '\n'
            continue
        # 匹配 AnnAssign 赋值模式
        # 例如: (a, b): Tuple[int, int] = (1, 2)
        match = re.match(r'(\s*)(\([^\)]+\)|\[[^\]]+\]|\S+)\s*:\s*([^=]+)=\s*(.+)', line)
        if match:
            indent = match.group(1)
            target = match.group(2)
            annotation = match.group(3)
            value = match.group(4)
            try:
                拆解赋值代码 = 拆解赋值(target, annotation, value, indent)
                拆解后的代码 += 拆解赋值代码
            except ValueError as e:
                print(f"拆解失败: {e} 在行: {line}")
                拆解后的代码 += line + '\n'
        else:
            拆解后的代码 += line + '\n'
    return 拆解后的代码


# 示例使用
if __name__ == "__main__":
    原始代码 = """
class 示例类:
    def __init__(起始接口):
        (a, b): Tuple[int, int] = (1, 2)
        ((c, d), e): Tuple[Tuple[float, float], str] = ((3.14, 2.718), "nested")
        [f, g]: List[int] = [4, 5]
        (h, [i, j]): Tuple[int, List[str]] = (6, ["hello", "world"])
        [[k, l], m]: List[List[int], str] = [[7, 8], "three"]
"""

    print("原始代码:")
    print(原始代码)

    拆解后的代码 = 拆解源代码中的注解赋值(原始代码)

    print("拆解后的代码:")
    print(拆解后的代码)
